home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung (Tewi)(1994).iso / magazine / nan_news / toolkit / tmenu.asm < prev    next >
Assembly Source File  |  1991-08-15  |  39KB  |  748 lines
  1. ; File......: TMENU.ASM
  2. ; Author....: Ted Means
  3. ; Date......: $Date:   15 Aug 1991 23:07:14  $
  4. ; Revision..: $Revision:   1.2  $
  5. ; Log file..: $Logfile:   E:/nanfor/src/tmenu.asv  $
  6. ; 
  7. ; This is an original work by Ted Means and is placed in the
  8. ; public domain.
  9. ;
  10. ; Modification history:
  11. ; ---------------------
  12. ;
  13. ; $Log:   E:/nanfor/src/tmenu.asv  $
  14. ;  
  15. ;     Rev 1.2   15 Aug 1991 23:07:14   GLENN
  16. ;  Forest Belt proofread/edited/cleaned up doc
  17. ;  
  18. ;     Rev 1.1   14 Jun 1991 19:55:00   GLENN
  19. ;  Minor edit to file header
  20. ;  
  21. ;     Rev 1.0   01 Apr 1991 01:03:56   GLENN
  22. ;  Nanforum Toolkit
  23. ;  
  24.  
  25. ; This source code is used by Toolkit sources ATPROMPT.PRG and 
  26. ; MENUTO.PRG.  Look at that code for details on the TMENU system.
  27.  
  28. ; This code depends on "TMENU.INC"
  29. ;
  30.  
  31.         IDEAL
  32.  
  33. Public   __ftprompt, __ftmenuto
  34.  
  35. Include  "TMENU.INC"
  36.  
  37. Extrn    __ParInfa:Far
  38. Extrn    __ParCLen:Far
  39. Extrn    __ParC:Far
  40. Extrn    __ParNI:Far
  41. Extrn    __RetNL:Far
  42. Extrn    __Ret:Far
  43. Extrn    __XGrab:Far
  44. Extrn    __XFree:Far
  45. Extrn    __XUnlock:Far
  46.  
  47. Segment  _MenuData Word      "DATA"
  48.  
  49. PrCount  DW        0
  50.  
  51. Label    HeadPtr   DWord                     ; Pointer to head of linked list
  52. HeadOfs  DW        0                         ; of menu items
  53. HeadSeg  DW        0
  54.  
  55. Ends     _MenuData
  56.  
  57.  
  58. Segment  _NanFor   Word      "CODE"
  59.          Assume    CS:_NanFor,ES:_MenuData
  60.  
  61. Proc     __ftprompt Far
  62.  
  63. NewItem: Mov       AX,42                     ; Specify size of menu item
  64.          Push      AX                        ; Put on stack
  65.          Call      __XGrab                   ; Allocate RAM for it
  66.          Add       SP,2                      ; Realign stack
  67.  
  68.          Mov       BX,_MenuData              ; Load local data segment
  69.          Mov       ES,BX                     ; Now put it in a segment reg
  70.          Inc       [ES:PrCount]              ; Increment prompt counter
  71.          Push      [ES:PrCount]              ; We'll need it later
  72.  
  73.          XChg      AX,[ES:HeadOfs]           ; Swap offsets
  74.          XChg      DX,[ES:HeadSeg]           ; Swap segments
  75.          LES       BX,[ES:HeadPtr]           ; Get pointer to new item
  76.          Mov       [MenuItem.NextOfs],AX     ; Move old head pointer to newly
  77.          Mov       [MenuItem.NextSeg],DX     ; allocated menu item
  78.  
  79. GetInfo: Pop       [MenuItem.PrNum]          ; Get prompt counter back
  80.          Push      BP                        ; Save BP
  81.          Mov       BP,SP                     ; Set up stack reference
  82.          Sub       SP,4                      ; Allocate local storage
  83.          Mov       [NodeOfs],BX              ; Save pointer in ES:BX in local
  84.          Mov       [NodeSeg],ES              ; storage -- avoids constant
  85.                                              ; pushing and popping
  86.  
  87.          Mov       AX,1                      ; Specify first parameter
  88.          Push      AX                        ; Put on stack
  89.          Call      __ParNI                   ; Get prompt location
  90.          Add       SP,2                      ; Realign stack
  91.          LES       BX,[NodePtr]              ; Restore node pointer
  92.          Mov       [MenuItem.PrLoc],AX       ; Store prompt location
  93.  
  94.          Mov       AX,2                      ; Specify second parameter
  95.          Push      AX                        ; Put on stack
  96.          Call      __ParClen                 ; Get length
  97.          Add       SP,2                      ; Realign stack
  98.  
  99.          Push      AX                        ; Put length on stack
  100.          Call      __XGrab                   ; Allocate RAM for copy
  101.          Push      DX                        ; Put copy pointer on stack for
  102.          Push      AX                        ; call to _ftStrDup
  103.  
  104.          Mov       AX,2                      ; Specify second parmeter
  105.          Push      AX                        ; Put on stack
  106.          Call      __ParC                    ; Get pointer to prompt
  107.          Add       SP,2                      ; Realign stack
  108.          Push      DX                        ; Put prompt pointer on stack
  109.          Push      AX                        ; for call to _ftStrDup
  110.  
  111.          Call      _ftStrDup                 ; Copy the prompt string
  112.          Add       SP,4                      ; Realign stack
  113.          LES       BX,[NodePtr]              ; Restore node pointer
  114.          Pop       [MenuItem.PrOfs]          ; Store prompt offset
  115.          Pop       [MenuItem.PrSeg]          ; Store prompt offset
  116.          Pop       [MenuItem.PrLen]          ; Store prompt length
  117.          Call      __XUnlock                 ; Tell VMM it's okay to let go
  118.  
  119.          Mov       AX,3                      ; Specify third parmeter
  120.          Push      AX                        ; Put on stack
  121.          Call      __ParNI                   ; Get prompt attribute
  122.          Add       SP,2                      ; Realign stack
  123.          LES       BX,[NodePtr]              ; Restore node pointer
  124.          Mov       [MenuItem.PrAtt],AL       ; Store attribute
  125.  
  126.          Mov       AX,4                      ; Specify fourth parameter
  127.          Push      AX                        ; Put on stack
  128.          Call      __ParNI                   ; Get message location
  129.          Add       SP,2                      ; Realign stack
  130.          LES       BX,[NodePtr]              ; Restore node pointer
  131.          Mov       [MenuItem.MsgLoc],AX      ; Store location
  132.  
  133.          Mov       AX,5                      ; Specify fifth parameter
  134.          Push      AX                        ; Put on stack
  135.          Call      __ParClen                 ; Get length
  136.          Add       SP,2                      ; Realign stack
  137.  
  138.          Push      AX                        ; Put length on stack
  139.          Call      __XGrab                   ; Allocate RAM for copy
  140.          Push      DX                        ; Put copy pointer on stack for
  141.          Push      AX                        ; call to _ftStrDup
  142.  
  143.          Mov       AX,5                      ; Specify fifth parmeter
  144.          Push      AX                        ; Put on stack
  145.          Call      __ParC                    ; Get pointer to message
  146.          Add       SP,2                      ; Realign stack
  147.          Push      DX                        ; Put message pointer on stack
  148.          Push      AX                        ; for call to _ftStrDup
  149.  
  150.          Call      _ftStrDup                 ; Copy the prompt string
  151.          Add       SP,4                      ; Realign stack
  152.          LES       BX,[NodePtr]              ; Restore node pointer
  153.          Pop       [MenuItem.MsgOfs]         ; Store message offset
  154.          Pop       [MenuItem.MsgSeg]         ; Store message segment
  155.          Pop       [MenuItem.MsgLen]         ; Store message length
  156.          Call      __XUnlock                 ; Tell VMM it's okay to let go
  157.          LES       BX,[NodePtr]              ; Restore node pointer
  158.  
  159.          Mov       AX,[MenuItem.MsgLen]      ; Get message length
  160.          SHL       AX,1                      ; Multiply by two
  161.          Push      AX                        ; Put buffer size on stack
  162.          Call      __XGrab                   ; Allocate buffer
  163.          Add       SP,2                      ; Realign stack
  164.          LES       BX,[NodePtr]              ; Restore node pointer
  165.          Mov       [MenuItem.BufOfs],AX      ; Store buffer offset
  166.          Mov       [MenuItem.BufSeg],DX      ; Store buffer segment
  167.  
  168.          Mov       AX,6                      ; Specify sixth parmeter
  169.          Push      AX                        ; Put on stack
  170.          Call      __ParNI                   ; Get message attribute
  171.          Add       SP,2                      ; Realign stack
  172.          LES       BX,[NodePtr]              ; Restore node pointer
  173.          Mov       [MenuItem.MsgAtt],AL      ; Store attribute
  174.  
  175.          Mov       AX,7                      ; Specify seventh parameter
  176.          Push      AX                        ; Save on stack
  177.          Call      __ParNI                   ; Get hotkey attribute
  178.          Add       SP,2                      ; Realign stack
  179.          LES       BX,[NodePtr]              ; Restore node pointer
  180.          Mov       [MenuItem.HKeyAtt],AL     ; Store hotkey attribute
  181.  
  182.          Mov       AX,8                      ; Specify eighth parameter
  183.          Push      AX                        ; Save on stack
  184.          Call      __ParNI                   ; Get hotkey location
  185.          Add       SP,2                      ; Realign stack
  186.          LES       BX,[NodePtr]              ; Restore node pointer
  187.          Mov       [MenuItem.HKeyLoc],AX     ; Store hotkey location
  188.  
  189.          Mov       AX,9                      ; Specify ninth parameter
  190.          Push      AX                        ; Save on stack
  191.          Call      __ParNI                   ; Get light bar attribute
  192.          Add       SP,2                      ; Realign stack
  193.          LES       BX,[NodePtr]              ; Restore node pointer
  194.          Mov       [MenuItem.HKeyVal],AL     ; Store hotkey value
  195.  
  196.          Mov       AX,10                     ; Specify tenth parameter
  197.          Push      AX                        ; Save on stack
  198.          Call      __ParNI                   ; Get light bar attribute
  199.          Add       SP,2                      ; Realign stack
  200.          LES       BX,[NodePtr]              ; Restore node pointer
  201.          Mov       [MenuItem.LBarAtt],AL     ; Store light bar attribute
  202.  
  203.          Mov       AX,11                     ; Specify eleventh parameter
  204.          Push      AX                        ; Save on stack
  205.          Call      __ParNI                   ; Get hotkey/lightbar attribute
  206.          Add       SP,2                      ; Realign stack
  207.          LES       BX,[NodePtr]              ; Restore node pointer
  208.          Mov       [MenuItem.LBHKAtt],AL     ; Store hotkey/lightbar attribute
  209.  
  210.          Mov       AX,12                     ; Specify twelfth parameter
  211.          Push      AX                        ; Save on stack
  212.          Call      __ParNI                   ; Get up arrow target
  213.          Add       SP,2                      ; Realign stack
  214.          LES       BX,[NodePtr]              ; Restore node pointer
  215.          Mov       [MenuItem.Up],AX          ; Store up arrow target
  216.  
  217.          Mov       AX,13                     ; Specify thirteenth parameter
  218.          Push      AX                        ; Save on stack
  219.          Call      __ParNI                   ; Get down arrow target
  220.          Add       SP,2                      ; Realign stack
  221.          LES       BX,[NodePtr]              ; Restore node pointer
  222.          Mov       [MenuItem.Down],AX        ; Store down arrow target
  223.  
  224.          Mov       AX,14                     ; Specify fourteenth parameter
  225.          Push      AX                        ; Save on stack
  226.          Call      __ParNI                   ; Get right arrow target
  227.          Add       SP,2                      ; Realign stack
  228.          LES       BX,[NodePtr]              ; Restore node pointer
  229.          Mov       [MenuItem.Right],AX       ; Store right arrow target
  230.  
  231.          Mov       AX,15                     ; Specify fifteenth parameter
  232.          Push      AX                        ; Save on stack
  233.          Call      __ParNI                   ; Get left arrow target
  234.          Add       SP,2                      ; Realign stack
  235.          LES       BX,[NodePtr]              ; Restore node pointer
  236.          Mov       [MenuItem.Left],AX        ; Store left arrow target
  237.  
  238.          Call      __Ret                     ; Return NIL
  239.          Mov       SP,BP                     ; Restore SP
  240.          Pop       BP                        ; Restore BP
  241.          Ret
  242. Endp     __ftprompt
  243.  
  244.  
  245.  
  246. Proc     _ftStrDup Near
  247.  
  248.          Push      BP                        ; Save BP
  249.          Mov       BP,SP                     ; Set up stack reference
  250.          Push      DS                        ; Save DS
  251.          Push      SI                        ; Save SI
  252.          Push      DI                        ; Save DI
  253.          CLD                                 ; Ensure forward movement
  254.  
  255.          Mov       SI,[Word Ptr BP + 4]      ; Get source offset
  256.          Mov       DS,[Word Ptr BP + 6]      ; Get source segment
  257.          Mov       DI,[Word Ptr BP + 8]      ; Get target offset
  258.          Mov       ES,[Word Ptr BP + 10]     ; Get target segment
  259.          Mov       CX,[Word Ptr BP + 12]     ; Get string length
  260.          Rep       Movsb                     ; Copy string
  261.  
  262.          Pop       DI                        ; Restore DI
  263.          Pop       SI                        ; Restore SI
  264.          Pop       DS                        ; Restore DS
  265.          Pop       BP                        ; Restore BP
  266.          Ret
  267. Endp     _ftStrDup
  268.  
  269.  
  270.  
  271. Proc     __ftMenuTo Far
  272.  
  273.          Push      BP                        ; Save BP
  274.          Mov       BP,SP                     ; Set up stack reference
  275.          Sub       SP,24                     ; Allocate space for locals
  276.  
  277.          Mov       BX,_MenuData              ; Get local data segment
  278.          Mov       ES,BX                     ; Load into segment register
  279.          Mov       BX,[ES:PrCount]           ; Get prompt count
  280.          Or        BX,BX                     ; Any prompts yet?
  281.          JNZ       Okay                      ; Yes, so continue
  282.          Mov       AX,BX                     ; Get low word of return value
  283.          Mov       DX,BX                     ; Get high word of return value
  284.          Jmp       Done                      ; Exit with return of zero
  285.  
  286. Okay:    Mov       [Last],BX                 ; Store prompt count in local
  287.          Mov       [NodeSeg],ES              ; Store current node pointer
  288.          Mov       [NodeOfs],Offset ES:HeadOfs - 38
  289.  
  290. GetDesiredPrompt:
  291.          Mov       AX,1                      ; Specify first param
  292.          Push      AX                        ; Put on stack
  293.          Call      __ParNI                   ; Get parameter
  294.          Add       SP,2                      ; Realign stack
  295.          Mov       CX,1                      ; Set default value
  296.          Or        AX,AX                     ; Specified prompt = 0?
  297.          JZ        SetActivePrompt           ; If so, use default
  298.          Cmp       AX,[Last]                 ; Check AX against prompt count
  299.          JA        SetActivePrompt           ; If higher, use default
  300.          Mov       CX,AX                     ; Value okay, so use it
  301.  
  302. SetActivePrompt:
  303.          Mov       [Active],CX               ; Initalize active prompt
  304.  
  305. GetFlagValues:
  306.          Mov       AX,2                      ; Specify second param
  307.          Push      AX                        ; Put on stack
  308.          Call      __ParNI                   ; Get parameter
  309.          Add       SP,2                      ; Realign stack
  310.          Mov       [Flags],AX                ; Store flags
  311.  
  312. GetSetKeyStuff:
  313.          Xor       AX,AX                     ; Request element count
  314.          Push      AX                        ; Put on stack
  315.          Mov       AX,3                      ; Specify third param
  316.          Push      AX                        ; Put on stack
  317.          Call      __ParInfa                 ; Get setkey count
  318.          Mov       [SKCount],AX              ; Store key count
  319.          SHL       AX,1                      ; Multiply by by two
  320.          Push      AX                        ; Put result on stack
  321.          Call      __XGrab                   ; Allocate scan code table
  322.          Add       SP,6                      ; Realign stack
  323.          Mov       [SKOfs],AX                ; Store offset
  324.          Mov       [SKSeg],DX                ; Store segment
  325.          Mov       CX,[SKCount]              ; Set loop value
  326.          JCXZ      CheckForColor             ; If no setkeys, skip next part
  327. GetNextScanCode:
  328.          Push      CX                        ; Put element # on stack
  329.          Mov       AX,3                      ; Specify third param
  330.          Push      AX                        ; Put on stack
  331.          Call      __ParNI                   ; Get scancode
  332.          Add       SP,2                      ; Realign stack
  333.          Pop       CX                        ; Restore CX
  334.          Mov       BX,CX                     ; Load element # into BX
  335.          Dec       BX                        ; Compensate for zero start
  336.          SHL       BX,1                      ; Multiply by two
  337.          Add       BX,[SKOfs]                ; Add offset
  338.          Mov       ES,[SKSeg]                ; Load segment
  339.          Mov       [Word Ptr ES:BX],AX       ; Store scancode
  340.          Loop      GetNextScanCode           ; Do the next one
  341.  
  342. CheckForColor:
  343.          Mov       [VideoBase],0B800h        ; Default to color
  344.          Xor       AX,AX                     ; Clear AX
  345.          Mov       ES,AX                     ; Point ES to low memory
  346.          Cmp       [Word Ptr ES:463h],3D4h   ; Color video?
  347.          JE        VideoTest                 ; If so, don't change to mono
  348.          Mov       [VideoBase],0B000h        ; Change video base to mono
  349.          And       [Flags],NOT SnowFlag      ; If mono, don't check for snow
  350.          Jmp       AllocateHotKeys           ; Allocate hotkey table
  351.  
  352. VideoTest:
  353.          Mov       AH,12h                    ; EGA/VGA BIOS call
  354.          Mov       BL,10h                    ; Set BL to test value
  355.          Int       10h                       ; Call video BIOS
  356.          Cmp       BL,10h                    ; Did BL change?
  357.          JE        AllocateHotKeys           ; No, so leave snow flag alone
  358.          And       [Flags],NOT SnowFlag      ; EGA/VGA, set snow flag to false
  359.  
  360. AllocateHotKeys:
  361.          Push      [Last]                    ; Put prompt count on stack
  362.          Call      __XGrab                   ; Allocate hotkey table
  363.          Add       SP,2                      ; Realign stack
  364.          Mov       [TableSeg],DX             ; Store segment
  365.          Mov       [TableOfs],AX             ; Store offset
  366.  
  367. MainLoopSetup:
  368.          Push      DS                        ; Save DS
  369.          Push      SI                        ; Save SI
  370.          Push      DI                        ; Save DI
  371.          CLD                                 ; Ensure forward movement
  372.  
  373.          Mov       DX,3DAh                   ; Specify status port for later
  374.          Mov       CX,[Last]                 ; Initalize loop register
  375.          LES       BX,[NodePtr]              ; Initialize ES:BX
  376.  
  377. PromptLoopTop:
  378.          Push      CX                        ; Save loop counter
  379.          LES       BX,[NextPtr]              ; Get pointer to next node
  380.          Mov       AL,[MenuItem.HKeyVal]     ; Get hotkey value
  381.          LDS       SI,[TablePtr]             ; Get pointer to hotkey table
  382.          Add       SI,CX                     ; Adjust offset
  383.          Mov       [Byte Ptr SI - 1],AL      ; Store hotkey value
  384.          LDS       SI,[PrPtr]                ; Get pointer to prompt
  385.          Mov       CX,[MenuItem.PrLen]       ; Get prompt length
  386.          JCXZ      PromptLoopBottom          ; If length = 0, jump to bottom
  387.          Mov       AH,[MenuItem.PrAtt]       ; Get prompt attribute
  388.          Push      ES                        ; Save ES
  389.          Mov       DI,[MenuItem.PrLoc]       ; Get screen location offset
  390.          Mov       ES,[VideoBase]            ; Get screen location segment
  391.  
  392. PromptRead:
  393.          Lodsb                               ; Get a prompt character
  394.          Test      [Flags],SnowFlag          ; See if snow-check in effect
  395.          JZ        PromptWrite               ; If not, continue
  396.          CheckSnow                           ; Wait for vertical retrace
  397.  
  398. PromptWrite:
  399.          Stosw                               ; Write character and attribute
  400.          Loop      PromptRead                ; Do next character
  401.          Pop       ES                        ; Restore ES
  402.  
  403. GetHotKeyAttr:
  404.          Push      ES                        ; Save ES again
  405.          Mov       DI,[MenuItem.HKeyLoc]     ; Get hotkey location
  406.          Inc       DI                        ; Select attribute byte
  407.          Mov       AL,[MenuItem.HKeyAtt]     ; Get hotkey attribute
  408.          Mov       ES,[VideoBase]            ; Get video base segment
  409.          Test      [Flags],SnowFlag          ; See if snow-check in effect
  410.          JZ        HotKeyAttr                ; If not, continue
  411.          CheckSnow                           ; Wait for vertical retrace
  412. HotKeyAttr:
  413.          Stosb                               ; Change attribute byte
  414.          Pop       ES                        ; Restore ES
  415.  
  416. PromptLoopBottom:
  417.          Pop       CX                        ; Restore loop counter
  418.          Loop      PromptLoopTop             ; Do next prompt
  419.  
  420. GetActivePrompt:
  421.          LES       BX,[NodePtr]              ; Get pointer to last node
  422.          Mov       AX,[Active]               ; Load current active item
  423.  
  424. SearchLinkedList:
  425.          LES       BX,[NextPtr]              ; Get pointer to next item
  426.          Cmp       AX,[MenuItem.PrNum]       ; Found it yet?
  427.          JNE       SearchLinkedList          ; Nope, so keep looking
  428.  
  429. LightBarStuff:
  430.          Push      ES                        ; Save ES
  431.          Mov       AL,[MenuItem.LBarAtt]     ; Get light bar attribute
  432.          Mov       CX,[MenuItem.PrLen]       ; Get prompt length
  433.          JCXZ      LightBarEnd               ; If length = 0, don't bother
  434.          Mov       DI,[MenuItem.PrLoc]       ; Get prompt location
  435.          Mov       ES,[VideoBase]            ; Load video base segment
  436. SetLightBarPtr:
  437.          Inc       DI                        ; Locate attribute byte
  438.          Test      [Flags],SnowFlag          ; Check for snow?
  439.          JZ        WriteLightBar             ; If not, continue
  440.          CheckSnow                           ; Wait for vertical retrace
  441. WriteLightBar:
  442.          Stosb                               ; Change attribute
  443.          Loop      SetLightBarPtr            ; Do next byte
  444. LightBarEnd:
  445.          Pop       ES                        ; Restore ES
  446.  
  447. GetLightBarHotKeyAttr:
  448.          Push      ES                        ; Save ES again
  449.          Mov       DI,[MenuItem.HKeyLoc]     ; Get hotkey location
  450.          Inc       DI                        ; Select attribute byte
  451.          Mov       AL,[MenuItem.LBHKAtt]     ; Get hotkey/lightbar attribute
  452.          Mov       ES,[VideoBase]            ; Get video base segment
  453.          Test      [Flags],SnowFlag          ; See if snow-check in effect
  454.          JZ        LightBarHotKeyAttr        ; If not, continue
  455.          CheckSnow                           ; Wait for vertical retrace
  456. LightBarHotKeyAttr:
  457.          Stosb                               ; Change attribute byte
  458.          Pop       ES                        ; Restore ES
  459.  
  460. BufferStuff:
  461.          Test      [Flags],SKFlag            ; Is setkey flag set?
  462.          JNZ       MessageStuff              ; If so, buffer already current
  463.          Push      ES                        ; Save ES
  464.          Mov       CX,[MenuItem.MsgLen]      ; Get message length
  465.          JCXZ      MessageEnd                ; If length = 0, don't bother
  466.          Mov       DS,[VideoBase]            ; Set DS to video RAM
  467.          Mov       SI,[MenuItem.MsgLoc]      ; Get message screen location
  468.          LES       DI,[BufPtr]               ; Get pointer to buffer
  469.          Test      [Flags],SnowFlag          ; Check for snow?
  470.          JZ        FastBuffer                ; If not, use fast method
  471. SlowBuffer:
  472.          CheckSnow                           ; Wait for vertical retrace
  473.          Movsw                               ; Store character and attribute
  474.          Loop      SlowBuffer                ; Do next character
  475. FastBuffer:
  476.          Rep       Movsw                     ; Store buffer
  477.          Pop       ES                        ; Restore ES
  478.  
  479. MessageStuff:
  480.          And       [Flags],NOT SKFlag        ; Turn setkey flag off
  481.          Push      ES                        ; Save ES
  482.          Mov       CX,[MenuItem.MsgLen]      ; Get message length
  483.          JCXZ      MessageEnd                ; If length = 0, no message
  484.          LDS       SI,[MsgPtr]               ; Get pointer to message
  485.          Mov       AH,[MenuItem.MsgAtt]      ; Get message attribute
  486.          Mov       DI,[MenuItem.MsgLoc]      ; Get message location
  487.          Mov       ES,[VideoBase]            ; Point ES to video RAM
  488. MessageRead:
  489.          Lodsb                               ; Get a message byte
  490.          Test      [Flags],SnowFlag          ; Check for snow?
  491.          JZ        MessageWrite              ; Skip snow check
  492.          CheckSnow                           ; Wait for vertical retrace
  493. MessageWrite:
  494.          Stosw                               ; Write char and attribute
  495.          Loop      MessageRead               ; Get next byte
  496. MessageEnd:
  497.          Pop       ES                        ; Restore ES
  498.  
  499. CheckForHotKey:
  500.          Test      [Flags],HotFlag           ; Hotkey pending?
  501.          JZ        GetNextKey                ; If not, get next key
  502.          Test      [Flags],ColdFlag          ; Hotkeys supposed to act cold?
  503.          JNZ       GetNextKey                ; If so, continue
  504.          Jmp       ExitWithSelection         ; We're finished
  505.  
  506. GetNextKey:
  507.          And       [Flags],NOT HotFlag       ; Make sure hotflag is off
  508.          Mov       AH,0                      ; BIOS service -- keyboard input
  509.          Int       16h                       ; Get a keystroke
  510.          Or        AL,AL                     ; Extended keystroke?
  511.          JZ        CheckForSetKey            ; If so, continue
  512.          Mov       AH,0                      ; Clear scan code -- ASCII in AL
  513.  
  514. CheckForSetKey:
  515.          Mov       [ScanCode],AX             ; Store most recent scancode
  516.          Mov       CX,[SKCount]              ; Get setkey count
  517.          JCXZ      CheckEscapeKey            ; If 0, no need for table check
  518.          Push      ES                        ; Save ES
  519.          LES       DI,[SetKeys]              ; Get pointer to setkey table
  520.          Repnz     Scasw                     ; Look for extended scan code
  521.          Pop       ES                        ; Restore ES
  522.          JNZ       CheckEscapeKey            ; Not found; check other keys
  523.          Or        [Flags],KeepFlag          ; Turn keep flag on
  524.          Jmp       ExitWithSelection         ; Go back to execute SET KEY
  525.  
  526. CheckEscapeKey:
  527.          Cmp       AL,27                     ; Escape key?
  528.          JNE       CheckEnterKey             ; If not, check for enter
  529.          Mov       [Active],0                ; Set return value
  530.          Jmp       ExitWithSelection         ; See if prompts need deallocated
  531.  
  532. CheckEnterKey:
  533.          Cmp       AL,13                     ; Enter key?
  534.          JNE       CheckUpLeftArrow          ; If not, check arrow keys
  535.          Jmp       ExitWithSelection         ; See if prompts need deallocated
  536.  
  537. CheckUpLeftArrow:
  538.          Mov       CX,[MenuItem.Up]          ; Get up arrow target
  539.          Cmp       AX,4800h                  ; Up arrow key?
  540.          JE        ProcessUpLeftArrow        ; If so, process it
  541.          Mov       CX,[MenuItem.Left]        ; Get left arrow target
  542.          Cmp       AX,4B00h                  ; Left arrow key?
  543.          JE        ProcessUpLeftArrow        ; If so, process it
  544.          Jmp       CheckDownRightArrow       ; Check for right or down arrow
  545. ProcessUpLeftArrow:
  546.          Or        CX,CX                     ; Default behavior requested?
  547.          JZ        UpLeftDefault             ; If so, go to previous prompt
  548.          Cmp       CX,[Last]                 ; Target beyond range?
  549.          JA        UpLeftDefault             ; If so, use default behavior
  550.          Jmp       GetNewPrompt              ; Get new prompt
  551. UpLeftDefault:
  552.          Mov       CX,[Active]               ; Load active prompt
  553.          Cmp       CX,1                      ; First prompt active?
  554.          JE        UpLeftWrap                ; If so, check for wrap
  555.          Dec       CX                        ; Decrement active prompt
  556.          Jmp       UpLeftExit                ; Exit
  557. UpLeftWrap:
  558.          Test      [Flags],WrapFlag          ; Wrapping requested?
  559.          JZ        UpLeftExit                ; If not, exit
  560.          Mov       CX,[Last]                 ; Wrap to last prompt
  561. UpLeftExit:
  562.          Jmp       GetNewPrompt              ; Get new prompt
  563.  
  564. CheckDownRightArrow:
  565.          Mov       CX,[MenuItem.Down]        ; Get down arrow target
  566.          Cmp       AX,5000h                  ; Down arrow key?
  567.          JE        ProcessRightDownArrow     ; If so, process it
  568.          Mov       CX,[MenuItem.Right]       ; Get right arrow target
  569.          Cmp       AX,4D00h                  ; Right arrow key?
  570.          JE        ProcessRightDownArrow     ; If so, process it
  571.          Jmp       CheckHotKeyTable          ; Check hotkey table
  572. ProcessRightDownArrow:
  573.          Or        CX,CX                     ; Default behavior requested?
  574.          JZ        DownRightDefault          ; If so, go to previous prompt
  575.          Cmp       CX,[Last]                 ; Target beyond range?
  576.          JA        DownRightDefault          ; If so, use default behavior
  577.          Jmp       GetNewPrompt              ; Get new prompt
  578. DownRightDefault:
  579.          Mov       CX,[Active]               ; Load active prompt
  580.          Cmp       CX,[Last]                 ; Last? prompt active?
  581.          JE        DownRightWrap             ; If so, check for wrap
  582.          Inc       CX                        ; Increment active prompt
  583.          Jmp       DownRightExit             ; Exit
  584. DownRightWrap:
  585.          Test      [Flags],WrapFlag          ; Wrapping requested?
  586.          JZ        DownRightExit             ; If not, exit
  587.          Mov       CX,1                      ; Wrap to last prompt
  588. DownRightExit:
  589.          Jmp       GetNewPrompt              ; Get new prompt
  590.  
  591. CheckHotKeyTable:
  592.          Push      ES                        ; Save ES
  593.          Cmp       AL,'a'                    ; Check for lowercase a
  594.          JB        LoadHotKeyTable           ; If below, don't convert
  595.          Cmp       AL,'z'                    ; Check for lowercase z
  596.          JA        LoadHotKeyTable           ; If above, don't convert
  597.          And       AL,0DFh                   ; Convert to uppercase
  598. LoadHotKeyTable:  
  599.          LES       DI,[TablePtr]             ; Get pointer to table
  600.          Add       DI,[Active]               ; Compensate for active prompt
  601.          Mov       CX,[Last]                 ; Get last prompt
  602.          Cmp       CX,[Active]               ; At last prompt now?
  603.          JE        TableWrap                 ; If so, need to wrap
  604.          Sub       CX,[Active]               ; # of prompts to end
  605.          Repne     Scasb                     ; Look for value
  606.          JNZ       TableWrap                 ; If not found, wrap to start
  607.          Pop       ES                        ; Restore ES
  608.          Sub       CX,[Last]                 ; Subtract prompt count
  609.          Jmp       EvaluateHotKey            ; Evaluate hotkey
  610. TableWrap:
  611.          LES       DI,[TablePtr]             ; Get pointer to table
  612.          Mov       CX,[Active]               ; Set CX to active prompt
  613.          Repne     Scasb                     ; Look for value
  614.          Pop       ES                        ; Restore ES
  615.          JNZ       KeepSamePrompt            ; Invalid key, get another one
  616.          Sub       CX,[Active]               ; Subtract prompt offset
  617. EvaluateHotKey:
  618.          Neg       CX                        ; Get absolute value
  619.          Or        [Flags],HotFlag           ; Turn hotflag on
  620.          Jmp       GetNewPrompt              ; Get new prompt
  621.  
  622. KeepSamePrompt:
  623.          Jmp       CheckForHotKey            ; Discard key and get another
  624.  
  625. GetNewPrompt:
  626.          Cmp       CX,[Active]               ; Prompt changed?
  627.          JE        KeepSamePrompt            ; If not, keep it
  628.  
  629.          Mov       [Active],CX               ; Set active prompt
  630.          Push      ES                        ; Save ES
  631.          Mov       AL,[MenuItem.PrAtt]       ; Get prompt attribute
  632.          Mov       CX,[MenuItem.PrLen]       ; Get prompt length
  633.          JCXZ      BarIsDead                 ; If length = 0, don't bother
  634.          Mov       DI,[MenuItem.PrLoc]       ; Get prompt location
  635.          Mov       ES,[VideoBase]            ; Load video base segment
  636. KillLightBar:
  637.          Inc       DI                        ; Locate attribute byte
  638.          Test      [Flags],SnowFlag          ; Check for snow?
  639.          JZ        ResetPromptAttr           ; If not, continue
  640.          CheckSnow                           ; Wait for vertical retrace
  641. ResetPromptAttr:
  642.          Stosb                               ; Change attribute
  643.          Loop      KillLightBar              ; Do next byte
  644.          Pop       ES                        ; Restore ES
  645.          Push      ES                        ; Save ES again
  646.          Mov       DI,[MenuItem.HKeyLoc]     ; Get hotkey location
  647.          Inc       DI                        ; Select attribute byte
  648.          Mov       AL,[MenuItem.HKeyAtt]     ; Get hotkey attribute
  649.          Mov       ES,[VideoBase]            ; Get video base segment
  650.          Test      [Flags],SnowFlag          ; See if snow-check in effect
  651.          JZ        ResetHotKeyAttr           ; If not, continue
  652.          CheckSnow                           ; Wait for vertical retrace
  653. ResetHotKeyAttr:
  654.          Stosb                               ; Change attribute byte
  655. BarIsDead:
  656.          Pop       ES                        ; Restore ES
  657.  
  658. KillMessage:
  659.          Push      ES                        ; Save ES
  660.          Mov       CX,[MenuItem.MsgLen]      ; Get message length
  661.          JCXZ      MessageIsDead             ; If length = 0, don't bother
  662.          LDS       SI,[BufPtr]               ; Get pointer to buffer
  663.          Mov       DI,[MenuItem.MsgLoc]      ; Get message screen location
  664.          Mov       ES,[VideoBase]            ; Set DS to video RAM
  665.          Test      [Flags],SnowFlag          ; Check for snow?
  666.          JZ        QuickDeath                ; If not, use fast method
  667. SlowDeath:
  668.          CheckSnow                           ; Wait for vertical retrace
  669.          Movsw                               ; Store character and attribute
  670.          Loop      SlowDeath                 ; Do next character
  671. QuickDeath:
  672.          Rep       Movsw                     ; Store buffer
  673. MessageIsDead:
  674.          Pop       ES                        ; Restore ES
  675.          Jmp       GetActivePrompt           ; Go to top of loop
  676.  
  677. Done:    Push      DX                        ; Put high word on stack
  678.          Push      AX                        ; Put low word on stack
  679.          Call      __RetNL                   ; Return value to app
  680.          Mov       SP,BP                     ; Restore SP
  681.          Pop       BP                        ; Restore BP
  682.          Ret
  683. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  684. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  685.  
  686.  
  687. ExitWithSelection:
  688.          Pop       DI                        ; Restore registers
  689.          Pop       SI
  690.          Pop       DS
  691.          Call      Near KillPrompts          ; Kill prompts if needed
  692.          Push      [TableSeg]                ; Hotkey table segment on stack
  693.          Push      [TableOfs]                ; HotKey table offset on stack
  694.          Call      __XFree                   ; Free allocated RAM
  695.          Push      [SKSeg]                   ; Scancode table segment on stack
  696.          Push      [SKOfs]                   ; Scancode table offset on stack
  697.          Call      __XFree                   ; Free allocated RAM
  698.          Mov       AX,[Active]               ; Set low order word
  699.          Mov       DX,[ScanCode]             ; Set high order word
  700.          Jmp       Done
  701.  
  702. KillPrompts:
  703.          Test      [Flags],KeepFlag          ; Supposed to keep prompts?
  704.          JZ        PromptDeallocSetup        ; If not, kill them
  705.          RetN                                ; Near return
  706.  
  707. PromptDeallocSetup:
  708.          LES       BX,[NodePtr]              ; Get first node pointer
  709.          Mov       CX,[Last]                 ; Get loop value
  710.          Mov       [ES:PrCount],0            ; Reset prompt counter
  711.          LES       BX,[NextPtr]              ; Get pointer to next item
  712.  
  713. KillAPrompt:
  714.          Mov       [NodeSeg],ES              ; Put ES:BX into local storage --
  715.          Mov       [NodeOfs],BX              ; saves pushing and popping
  716.          Push      [MenuItem.NextSeg]        ; Put next segment on stack
  717.          Push      [MenuItem.NextOfs]        ; Put next offset on stack
  718.  
  719.          Push      [MenuItem.PrSeg]          ; Put prompt segment on stack
  720.          Push      [MenuItem.PrOfs]          ; Put prompt offset on stack
  721.          Call      __XFree                   ; Free memory
  722.          LES       BX,[NodePtr]              ; Restore node pointer
  723.  
  724.          Push      [MenuItem.MsgSeg]         ; Put message segment on stack
  725.          Push      [MenuItem.MsgOfs]         ; Put message offset on stack
  726.          Call      __XFree                   ; Free memory
  727.          LES       BX,[NodePtr]              ; Restore node pointer
  728.  
  729.          Push      [MenuItem.BufSeg]         ; Put buffer segment on stack
  730.          Push      [MenuItem.BufOfs]         ; Put buffer offset on stack
  731.          Call      __XFree                   ; Free memory
  732.          LES       BX,[NodePtr]              ; Restore node pointer
  733.  
  734.          Push      ES                        ; Put node segment on stack
  735.          Push      BX                        ; Put node offset on stack
  736.          Call      __XFree                   ; Free memory
  737.          Add       SP,16                     ; Realign stack
  738.  
  739.          Pop       BX                        ; Get new node offset
  740.          Pop       ES                        ; Get new node segment
  741.          Loop      KillAPrompt               ; Kill next node
  742.          RetN                                ; Near return
  743.  
  744. Endp     __ftMenuTo
  745. Ends     _NanFor
  746. End
  747. 
  748.